package com.example.designpatterns.chain;

/**
 * Handler抽象类 - 定义责任链中的处理者
 */
public abstract class Handler {
    // 处理者名称
    protected String name;
    
    // 责任链中的下一个处理者
    protected Handler nextHandler;
    
    /**
     * 创建一个处理者
     * @param name 处理者名称
     */
    public Handler(String name) {
        this.name = name;
    }
    
    /**
     * 设置责任链中的下一个处理者
     * @param nextHandler 下一个处理者
     * @return 当前处理者，支持链式调用
     */
    public Handler setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
        return this;
    }
    
    /**
     * 处理请求的方法
     * 如果当前处理者无法处理，则传递给责任链中的下一个处理者
     * @param request 请求对象
     */
    public void handleRequest(Request request) {
        // 尝试处理请求
        if (canHandle(request)) {
            doHandle(request);
            return;
        }
        
        // 如果当前处理者不能处理，且有下一个处理者，则传递给下一个处理者
        if (nextHandler != null) {
            System.out.println(name + " 无法处理，传递请求给 " + nextHandler.name);
            nextHandler.handleRequest(request);
        } else {
            // 如果当前处理者是责任链中的最后一个处理者，且不能处理请求
            System.out.println("没有处理者能够处理该请求: " + request);
        }
    }
    
    /**
     * 判断当前处理者是否能处理请求
     * @param request 请求对象
     * @return 是否能处理
     */
    protected abstract boolean canHandle(Request request);
    
    /**
     * 处理请求的具体实现
     * @param request 请求对象
     */
    protected abstract void doHandle(Request request);
    
    /**
     * 获取处理者名称
     * @return 处理者名称
     */
    public String getName() {
        return name;
    }
} 